#define _USE_MATH_DEFINES
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <cmath>

using namespace std;

namespace GEO {
	const double eps = 0.0000001;
	enum SIDE_STATE {OUT, IN, ON};

	typedef struct TPoint {
		double x, y;
	} TPoint;

	TPoint tPoint(double x, double y) {
		TPoint t;
		t.x = x;
		t.y = y;
		return t;
	}

	typedef struct TShape {
		int num;
		bool isClockwise;
		TPoint* points;
	} TShape;

	TPoint operator + (TPoint a, TPoint b) {
		TPoint res;
		res.x = a.x + b.x;
		res.y = a.y + b.y;
		return res;
	}

	TPoint operator - (TPoint a, TPoint b) {
		TPoint res;
		res.x = a.x - b.x;
		res.y = a.y - b.y;
		return res;
	}

	TPoint operator * (double s, TPoint x) {
		TPoint res;
		res.x = s*x.x;
		res.y = s*x.y;
		return res;
	}
	bool eq(double x, double y) {return fabs(x-y)<eps;}
	bool operator == (TPoint a, TPoint b) {return eq(a.x, b.x) && eq(a.y, b.y);}

	std::ostream& operator<<(std::ostream& os, const TPoint& a) {
		return std::cout << a.x << " " << a.y;
	}

	double sqr(double x) {return x*x;}

	double norm2(TPoint a) {return sqr(a.x) + sqr(a.y);}
	double norm(TPoint a) {return sqrt(norm2(a));
	}

	double cross(TPoint a, TPoint b){return a.x*b.y - b.x*a.y;}

	double dot(TPoint a, TPoint b) {return a.x*b.x + a.y*b.y;}

	double calArea(TShape poly) {
		double area = 0;
		for (int i=0; i<poly.num; ++i)
			area += cross(poly.points[i], poly.points[i+1]);
		return fabs(area/2);
	}

	SIDE_STATE inShape(TPoint a, TShape s) {
		double deg = 0, tot = 0;
		TPoint u, v;
		for (int i=0; i<s.num; ++i) {
			u = s.points[i] - a;
			v = s.points[i+1] - a;
			deg = asin(cross(u, v) / (norm2(u)*norm2(v)));
			if (norm2(s.points[i]-s.points[i+1]) > norm2(u) + norm2(v)) {
				if (deg < eps) deg = -M_PI - deg;
				else if (deg > eps) deg = M_PI - deg;
				else {
					if (s.isClockwise) deg = -M_PI;
					else deg = M_PI;
					return ON;
				}
			}
			tot += deg;
		}
		return (fabs(tot)>1)?IN:OUT;//deg = 0(out) or deg = -2PI(in) or deg = 2PI(in)
	}

	TPoint getIntersection(TPoint a, TPoint b, TPoint u, TPoint v) {
		TPoint ret;
		double t1, t2;
		t1 = fabs(cross(u-a, v-a));
		t2 = fabs(cross(u-b, v-b));
		if (t1+t2 < eps) {
			t1 = dot(u-a, b-a);
			if (t1 > 0) ret = u;
			else ret = a;
		}
		else {
			ret.x = a.x+ t1/(t2+t1)*(b.x - a.x);
			ret.y = a.y+ t1/(t2+t1)*(b.y - a.y);
		}
		return ret;
	}

	TPoint rotate(TPoint p, double alpha) {
		return tPoint(p.x*cos(alpha)-p.y*sin(alpha), p.x*sin(alpha)+p.y*cos(alpha));
	}

	double absoluteAngel(TPoint x) {
		TPoint v = tPoint(100, 0);
		double rad = asin(cross(v, x) / (norm(x)*norm(v)));
		if (dot(v, x) < 0) {
			if (rad < 0)
				rad = -M_PI - rad;
			else
				rad = M_PI - rad;
		}
		return rad;
	}

	double tangentAngel(TPoint p, TPoint center, double r) {
		return 2 * fabs(asin(r/norm(center-p)));
	}

	TPoint tangentPoint(TPoint p, TPoint center, double r, int pOrN) {
		double angel = fabs(asin(r/norm(center-p)));
		return p + rotate(center - p, (pOrN>0)?angel:-angel);
	}
}

using namespace GEO;

int cnt = 0;
double diameter;
TPoint me;
typedef struct _TRange {
	double lower, upper;
} TRange;

TRange tRange(double l, double u) {
	TRange t;
	t.lower = l;
	t.upper = u;
	return t;
}

typedef struct _TNode {
	TRange view;
	TRange treeEdge;
	bool blocked;
	struct _TNode* upperTree;
	struct _TNode* lowerTree;
} TNode;

TNode root;
int available;
double eps1 = 0.01/180*M_PI;

bool inRange(double x, TRange y) {return (y.lower <= x+eps && x-eps <= y.upper);}

double toD(double rad) {return 180*rad/M_PI;}

bool tooSmall(const TRange& treeEdge) {
	return treeEdge.upper - treeEdge.lower < eps1;
}

bool canISee(const TRange& view, const TRange& treeEdge) {
	if (tooSmall(treeEdge)) return false;
	if (view.lower + eps1 < treeEdge.lower &&
		view.upper - eps1 > treeEdge.upper) 
		return true;
	return false;

}

bool canISee(TPoint tree, TRange view, TRange& treeEdge) {
// 	cout << "view: " << toD(view.lower) << " " << toD(view.upper) << endl;
	double deltaAngel = tangentAngel(me, tree, diameter/2)/2;
// 	cout << "delta angel: " << toD(deltaAngel) << endl;
	double angel = absoluteAngel(tree-me);
// 	cout << "absolute angel: " << toD(angel) << endl;
	treeEdge.lower = angel - deltaAngel;
	treeEdge.upper = angel + deltaAngel;
	return canISee(view, treeEdge);
}

//assume treeEdge not all in view
TRange updatedView( TRange view, TRange treeEdge ) 
{
	TRange newview = view;
	if (inRange(treeEdge.upper, view))
		newview.lower = treeEdge.upper;
	else if (inRange(treeEdge.lower, view))
		newview.upper = treeEdge.lower;
	else {
		newview.lower = treeEdge.upper;
		newview.upper = treeEdge.lower;
	}
	return newview;
}

bool eq(TRange x, TRange y) {
	return (eq(x.lower,y.lower) && eq(x.upper,y.upper));
}

void updateView(TNode &root, const TRange& treeEdge) {
	if (treeEdge.upper <= root.view.lower) return;
	if (treeEdge.lower >= root.view.upper) return;

	if (root.blocked) {
		if (root.upperTree != NULL) {
			if (root.upperTree->view.lower <= treeEdge.upper)
				updateView(*root.upperTree, treeEdge);
		}
		if (root.lowerTree != NULL) {
			if (root.lowerTree->view.upper >= treeEdge.lower)
				updateView(*root.lowerTree, treeEdge);
		}
		return;
	}
	
	if (canISee(root.view, treeEdge)) {
		++cnt;
		TNode* newNode = new TNode;
		newNode->blocked = false;
		newNode->lowerTree = 0;
		newNode->upperTree = 0;
		newNode->view.upper = root.view.upper;
		newNode->view.lower = treeEdge.upper;
		root.upperTree = newNode;

		newNode = new TNode;
		newNode->blocked = false;
		newNode->lowerTree = 0;
		newNode->upperTree = 0;
		newNode->view.upper = treeEdge.lower;
		newNode->view.lower = root.view.lower;
		root.lowerTree = newNode;

		root.blocked = true;
		root.treeEdge = treeEdge;
		
		available += 2;
		if (tooSmall(root.upperTree->view)) {
			--available;
			delete root.upperTree;
			root.upperTree = 0;
		}
		if (tooSmall(root.lowerTree->view)) {
			--available;
			delete root.lowerTree;
			root.lowerTree = 0;
		}

		--available;
		return;
	}

	if (treeEdge.lower <= root.view.lower + eps1) {
		TNode* newNode = new TNode;
		newNode->blocked = false;
		newNode->lowerTree = 0;
		newNode->upperTree = 0;
		newNode->view.upper = root.view.upper;
		newNode->view.lower = treeEdge.upper;
		root.upperTree = newNode;
		root.blocked = true;
		root.treeEdge = treeEdge;
		++available;
		if (tooSmall(root.upperTree->view)) {
			--available;
			delete root.upperTree;
			root.upperTree = 0;
		}
	}

	if (treeEdge.upper >= root.view.upper - eps1) {
		TNode* newNode = new TNode;
		newNode->blocked = false;
		newNode->lowerTree = 0;
		newNode->upperTree = 0;
		newNode->view.upper = treeEdge.lower;
		newNode->view.lower = root.view.lower;
		root.lowerTree = newNode;
		root.blocked = true;
		root.treeEdge = treeEdge;
		++available;
		if (tooSmall(root.lowerTree->view)) {
			--available;
			delete root.lowerTree;
			root.lowerTree = 0;
		}
	}

	if (root.blocked) --available;
}

int main(void)
{
	while (true) {
		scanf("%lf %lf %lf", &diameter, &me.x, &me.y);
		if (diameter < eps) break;

		TRange treeEdge;
		cnt = 0;

		for (int iter = 0; iter < 4; ++iter) {
			root.view = tRange(0, M_PI/2);
			root.upperTree = 0;
			root.lowerTree = 0;
			root.blocked = false;
			available = 1;

			for (int dis=2;; ++dis) {
				bool allTooSmall = true;
				for (int gridX=1; gridX<=dis-1; ++gridX) {
					int gridY = dis - gridX;
					canISee(tPoint(gridX, gridY), root.view, treeEdge);
					if (tooSmall(treeEdge)) continue;
					allTooSmall = false;
					updateView(root, treeEdge);
				}
				if (allTooSmall) break;
				if (available == 0) break;
			}
			double t = me.x;
			me.x = me.y;
			me.y = 1 - t;
		}
		cout << cnt << endl;

	}
	return 0;
}
